ZentinelBot

ZentinelBot is my robot designed to help keep spaces safe. It combines an ultrasonic sensor that allows it to “sense” nearby obstacles and a dual-lens IP camera that monitors everything in real time.

The idea is for ZentinelBot to patrol autonomously, avoiding collisions and sending images or alerts when it detects something unusual. Additionally, you can monitor and control it from your phone or computer, making it easy to stay aware even from a distance.

This project aims to create a practical, accessible, and modular solution that improves security without complications, designed for homes, offices, or any place needing constant surveillance.

Phase	Start Date	End Date	Progress
1. Concept and Design	Jan 30	May 15	100%
2. Computer-Controlled Cutting	May 19	May 20	100%
3. 3D Printing	May 1	May 10	100%
4. Electronics Design	Feb 26	March 5	100%
5. Electronics Production	Marh 14	May 10	100%
6. Embedded Programming	Feb 15	May 8	100%
7. Computer-Controlled Machining	May 16	May 21	100%
8. Input Devices	Marh 23	April 20	100%
9. Output Devices	Marh 29	April 27	100%
10. System Integration	May 10	May 30	100%
11. Final Testing and Documentation	May 15	June 04	100%

During the various assignments, I was able to learn and improve my designs using different CAD programs. For example, in week 2, I worked with SolidWorks and Inventor, creating several part designs. The structural design of my robot was developed in Inventor, where I also applied generative design techniques to optimize the structure and reduce weight.

Structural Design

The robot's design includes the main structure, the body, and various parts such as the limbs, as well as the support for the antennas and sensors. The structural frame serves as the base, providing stability and support for all the components.

The robot's structure was created using generative design techniques. This approach allowed me to optimize the structure by automatically exploring multiple design alternatives, focusing on reducing weight while maintaining strength and durability. Thanks to generative design, the final structure is efficient and robust, providing a solid foundation for the rest of the robot's components.

Once the working parameters have been set, we will proceed to load the generative design calculation:

Parts Design

Piece 1: unions

Piece 2: first leg

Piece 3: Second leg

Piece 4: Chest design

Piece 5: Antenna cover

Piece 6: Cover

Piece 7: Main structure

Piece 8: Antenna base

final design of the ZentinelBot robot

2.- 3D printing of parts

For printing the parts, we have exported the generated files in STL format. For printing small parts, the Bambu Lab printer was used, and for larger parts, the Proxy printer was used.

3.-Electronic Design

During week 6, we learned how to carry out electronic design, taking into account many aspects, such as design rules, electrical requirements such as voltages, currents and frequencies. I had certain knowledge, but with this week's development I reinforced it, making the design of my own board for my robot. To see more details of the electronic design, click here.

To perform electronic integration, we must make a list of the components we will use for the project:

• XIAO ESP32-C3
• ROB-14450 – Motor driver
• L7805CV – Voltage regulator
• Polarized capacitor
• Ultrasonic sensor
• Servomotor
• WS2812B LED strip

3.1 schematic diagram

3.2 PCB layout design

3.2 3D visualization

3.3 Component layout

4.-Electronic Production

During week 8, the assigned task was to manufacture the PCB based on the previously prepared electronic design. To do this, I used a CNC milling machine specialized in printed circuit board manufacturing, which allowed me to perform precise engraving and drilling. Tools such as milling cutters of different sizes were used to remove unwanted copper and create the circuit traces. In addition, parameters such as machine speed, cutting depth, and board cleanliness were taken into account to ensure an optimal and functional finish. Finally, the circuit's continuity and proper operation were verified before its integration into the project.

For more details you can see here Electronic production

5.-Embedded Programming

During week 4, we completed embedded programming, using the Arduino IDE development environment. In this stage, we wrote the initial codes to control the robot's sensors and actuators, such as the ultrasonic sensor, motors, and camera. The microcontroller's digital inputs and outputs were configured, the basic operating logic was established, and read and response tests were performed. This programming was essential for validating the expected behavior of the electronic components and laying the groundwork for the robot's autonomous control.

6.- Input Devices

In the robot's design, the primary input device used was the HC-SR04 ultrasonic sensor, which measures distances using sound waves. This sensor works by emitting an ultrasonic pulse from the Trigger pin and waiting for the reflected echo received on the Echo pin. The time it takes for the echo to return is used to calculate the distance to the object. During the testing phase, the sensor was connected to the ESP32-C3 microcontroller and programmed to detect obstacles in front of the robot. This information was essential for allowing the robot to react to the presence of objects, stopping or changing direction.

7.- Output Devices

During the initial tests and assigned tasks, we initially worked with a single DC motor coupled to a wheel as a load. This stage was essential for validating the motor's basic control and understanding output behavior under realistic weight and friction conditions.

8.-Electronic Programming

This code configures the ESP32-C3 XIAO microcontroller as a WiFi web server, allowing the robot to be controlled from a web browser over a local network. The user can access a graphical interface with buttons (forward, backward, left, right, stop) that, when pressed, send commands to the ESP32-C3 to activate the robot's motors.

#include <WiFi.h>
#include <WebServer.h>
#include <ESP32Servo.h>
#include <Adafruit_NeoPixel.h>

// Configuración WiFi
const char* ssid = "ESP_AP";
const char* password = "123456789";

// Definición de pines
#define STBY_PIN   10
#define AIN1_PIN   2
#define AIN2_PIN   3
#define PWMA_PIN   4
#define BIN1_PIN   5
#define BIN2_PIN   6
#define PWMB_PIN   7
#define TRIG_PIN   8
#define ECHO_PIN   9
#define SERVO_PIN  21
#define LED_PIN    20  // GPIO para la tira LED
#define LED_COUNT  96  // Número de LEDs en tu matriz

WebServer server(80);
Servo obstacleServo;
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);

// Variables para el modo autónomo
bool autonomousMode = false;
String currentDirection = "stop";
const int motorSpeed = 255;
const float safeDistance = 30.0;

// Configuración del servo
const int servoMinAngle = -45;
const int servoMaxAngle = 45;
const int servoCenter = 0;
int currentServoAngle = servoCenter;
bool servoMoving = false;
unsigned long lastServoMove = 0;
const int servoMoveInterval = 100;
int servoDelay = 40;

// Sensor ultrasónico
unsigned long lastPingTime = 0;
const int pingInterval = 100;
float currentDistances[3] = {0, 0, 0};
bool waitingForEcho = false;
unsigned long echoStartTime = 0;

// Estados
enum State { SCANNING, PROCESSING, MOVING };
State currentState = SCANNING;
unsigned long stateStartTime = 0;

// Red neuronal
const int InputNodes = 3;
const int HiddenNodes = 4;
const int OutputNodes = 4;
double Hidden[HiddenNodes];
double Output[OutputNodes];

float HiddenWeights[3][4] = {
    {1.8991509504079183, -0.4769472541445052, -0.6483690220539764, -0.38609165249078925},
    {-0.2818610915467527, 4.040695699457223, 3.2291858058243843, -2.894301104732614},
    {0.3340650864625773, -1.4016114422346901, 1.3580053902963762, -0.981415976256285}
};

float OutputWeights[4][4] = {
    {1.136072297461121, 1.54602394937381, 1.6194612259569254, 1.8819066696635067},
    {-1.546966506764457, 1.3951930739494225, 0.19393826092602756, 0.30992504138547006},
    {-0.7755982417649826, 0.9390808625728915, 2.0862510744685485, -1.1229484266101883},
    {-1.2357090352280826, 0.8583930286034466, 0.724702079881947, 0.9762852709700459}
};

// Image matrices for the LED strip (FILL THEM WITH YOUR VALUES!)
uint32_t frameForward[LED_COUNT] = {
  0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF,
  0x000000, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x000000,
  0x000000, 0x00FF00, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x00FF00, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFF00, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFF00, 0x000000, 0xFFFFFF, 0xFFFFFF
};

uint32_t frameBackward[LED_COUNT] = {
  0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF,
  0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x000000, 0x000000, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFF00, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFF00, 0x000000, 0xFFFFFF, 0xFFFFFF,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF
};

uint32_t frameLeft[LED_COUNT] = {
  0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF,
  0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000,
  0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFF00, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFF00, 0x000000, 0xFFFFFF, 0xFFFFFF,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF
};

uint32_t frameRight[LED_COUNT] = {
  0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0xFFFF00, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFF00, 0x000000, 0xFFFFFF, 0xFFFFFF,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF
};

uint32_t frameStop[LED_COUNT] = {
  0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF,
  0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000, 0x000000, 0x000000, 0x000000, 0x0000FF, 0x0000FF, 0x0000FF, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x000000, 0x000000, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000, 0x000000, 0x000000, 0x000000, 0x00FF00, 0xFF0000, 0x00FF00, 0x000000,
  0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x00FF00, 0x00FF00, 0x00FF00, 0x000000,
  0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x007FFF, 0x007FFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF,
  0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0xFFFF00, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF
};

// Función para mostrar imágenes en la tira LED
void showLEDFrame(uint32_t frame[]) {
  for(int i = 0; i < LED_COUNT; i++) {
    strip.setPixelColor(i, frame[i]);
  }
  strip.show();
}

void setup() {
  Serial.begin(115200);
  
  // Configuración de pines
  pinMode(STBY_PIN, OUTPUT);
  pinMode(AIN1_PIN, OUTPUT);
  pinMode(AIN2_PIN, OUTPUT);
  pinMode(PWMA_PIN, OUTPUT);
  pinMode(BIN1_PIN, OUTPUT);
  pinMode(BIN2_PIN, OUTPUT);
  pinMode(PWMB_PIN, OUTPUT);
  digitalWrite(STBY_PIN, HIGH);
  
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  digitalWrite(TRIG_PIN, LOW);
  
  obstacleServo.attach(SERVO_PIN, 500, 2500);
  obstacleServo.write(servoCenter);

  // Inicializa la tira LED
  strip.begin();
  strip.setBrightness(50); // Ajusta el brillo (0-255)
  strip.show(); // Apaga todos los LEDs inicialmente
  
  WiFi.softAP(ssid, password);
  Serial.print("IP del Access Point: ");
  Serial.println(WiFi.softAPIP());

  // Configura rutas del servidor web
  server.on("/", handleRoot);
  server.on("/forward", []() { if(!autonomousMode) moveRobot("forward"); server.send(200, "text/plain", "OK"); });
  server.on("/backward", []() { if(!autonomousMode) moveRobot("backward"); server.send(200, "text/plain", "OK"); });
  server.on("/left", []() { if(!autonomousMode) moveRobot("left"); server.send(200, "text/plain", "OK"); });
  server.on("/right", []() { if(!autonomousMode) moveRobot("right"); server.send(200, "text/plain", "OK"); });
  server.on("/stop", []() { if(!autonomousMode) moveRobot("stop"); server.send(200, "text/plain", "OK"); });
  server.on("/autonomous", []() { autonomousMode = true; currentState = SCANNING; server.send(200, "text/plain", "OK"); });
  server.on("/manual", []() { autonomousMode = false; moveRobot("stop"); server.send(200, "text/plain", "OK"); });
  server.on("/autonomousData", handleAutonomousData);
  
  server.begin();
}

void loop() {
  server.handleClient();
  if(autonomousMode) autonomousRoutine();
}

void autonomousRoutine() {
  unsigned long currentTime = millis();
  
  switch(currentState) {
    case SCANNING:
      handleScanningState(currentTime);
      break;
    case PROCESSING:
      handleProcessingState(currentTime);
      break;
    case MOVING:
      handleMovingState(currentTime);
      break;
  }
  
  handleUltrasonicSensor(currentTime);
}

void handleScanningState(unsigned long currentTime) {
  static int scanStep = 0;
  const int scanAngles[3] = {servoMinAngle, servoCenter, servoMaxAngle};
  
  if(!servoMoving && currentTime - lastServoMove >= servoMoveInterval) {
    if(scanStep < 3) {
      currentServoAngle = scanAngles[scanStep];
      obstacleServo.write(currentServoAngle);
      servoMoving = true;
      lastServoMove = currentTime;
      servoDelay = (scanStep == 0 || scanStep == 2) ? 80 : 40;
      startPing();
    } else {
      currentState = PROCESSING;
      stateStartTime = currentTime;
      scanStep = 0;
    }
  }
  
  if(servoMoving && currentTime - lastServoMove >= servoDelay) {
    servoMoving = false;
    scanStep++;
  }
}

void handleProcessingState(unsigned long currentTime) {
  if(currentTime - stateStartTime >= 100) {
    processNeuralNetwork(currentDistances);
    currentState = MOVING;
    stateStartTime = currentTime;
  }
}

void handleMovingState(unsigned long currentTime) {
  if(currentTime - stateStartTime >= 300) {
    currentState = SCANNING;
    stateStartTime = currentTime;
  }
}

void handleUltrasonicSensor(unsigned long currentTime) {
  static bool waitingForEcho = false;
  static unsigned long pingTime = 0;
  
  if(!waitingForEcho && currentTime - lastPingTime >= pingInterval) {
    startPing();
    lastPingTime = currentTime;
    waitingForEcho = true;
    pingTime = currentTime;
  }
  
  if(waitingForEcho) {
    long duration = pulseIn(ECHO_PIN, HIGH, 10000);
    
    if(duration > 0) {
      float distance = duration * 0.034 / 2.0;
      
      if(currentServoAngle <= -30) {
        currentDistances[0] = distance;
      } else if(currentServoAngle >= 30) {
        currentDistances[2] = distance;
      } else {
        currentDistances[1] = distance;
      }
      
      waitingForEcho = false;
    } else if(currentTime - pingTime > 50) {
      waitingForEcho = false;
    }
  }
}

void startPing() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
}

void moveRobot(String direction) {
  currentDirection = direction;
  
  // Mostrar imagen en la tira LED según el movimiento
  if(direction == "forward") {
    showLEDFrame(frameForward);
    digitalWrite(AIN1_PIN, HIGH);
    digitalWrite(AIN2_PIN, LOW);
    analogWrite(PWMA_PIN, motorSpeed);
    digitalWrite(BIN1_PIN, HIGH);
    digitalWrite(BIN2_PIN, LOW);
    analogWrite(PWMB_PIN, motorSpeed);
  }
  else if(direction == "backward") {
    showLEDFrame(frameBackward);
    digitalWrite(AIN1_PIN, LOW);
    digitalWrite(AIN2_PIN, HIGH);
    analogWrite(PWMA_PIN, motorSpeed);
    digitalWrite(BIN1_PIN, LOW);
    digitalWrite(BIN2_PIN, HIGH);
    analogWrite(PWMB_PIN, motorSpeed);
  }
  else if(direction == "left") {
    showLEDFrame(frameLeft);
    digitalWrite(AIN1_PIN, LOW);
    digitalWrite(AIN2_PIN, HIGH);
    analogWrite(PWMA_PIN, motorSpeed);
    digitalWrite(BIN1_PIN, HIGH);
    digitalWrite(BIN2_PIN, LOW);
    analogWrite(PWMB_PIN, motorSpeed);
  }
  else if(direction == "right") {
    showLEDFrame(frameRight);
    digitalWrite(AIN1_PIN, HIGH);
    digitalWrite(AIN2_PIN, LOW);
    analogWrite(PWMA_PIN, motorSpeed);
    digitalWrite(BIN1_PIN, LOW);
    digitalWrite(BIN2_PIN, HIGH);
    analogWrite(PWMB_PIN, motorSpeed);
  }
  else { // stop
    showLEDFrame(frameStop);
    digitalWrite(AIN1_PIN, LOW);
    digitalWrite(AIN2_PIN, LOW);
    analogWrite(PWMA_PIN, 0);
    digitalWrite(BIN1_PIN, LOW);
    digitalWrite(BIN2_PIN, LOW);
    analogWrite(PWMB_PIN, 0);
  }
}

void processNeuralNetwork(float* inputs) {
  float normalizedInputs[3];
  for(int i = 0; i < 3; i++) {
    normalizedInputs[i] = constrain(inputs[i], 0, 100) / 100.0;
  }
  
  for(int h = 0; h < HiddenNodes; h++) {
    Hidden[h] = 0;
    for(int i = 0; i < InputNodes; i++) {
      Hidden[h] += normalizedInputs[i] * HiddenWeights[i][h];
    }
    Hidden[h] = tanh(Hidden[h]);
  }
  
  for(int o = 0; o < OutputNodes; o++) {
    Output[o] = 0;
    for(int h = 0; h < HiddenNodes; h++) {
      Output[o] += Hidden[h] * OutputWeights[h][o];
    }
    Output[o] = tanh(Output[o]);
  }
  
  executeNeuralDecision();
}

void executeNeuralDecision() {
  const float minDistance = 25.0;
  
  if(currentDistances[1] > minDistance) {
    moveRobot("forward");  // Mostrará frameForward
  }
  else {
    if(currentDistances[0] > currentDistances[2]) {
      moveRobot("left");   // Mostrará frameLeft
    } else {
      moveRobot("right");  // Mostrará frameRight
    }
  }
}

void handleAutonomousData() {
  String decision;
  if(currentDirection == "forward") decision = "Avanzando";
  else if(currentDirection == "backward") decision = "Retrocediendo";
  else if(currentDirection == "left") decision = "Girando izquierda";
  else if(currentDirection == "right") decision = "Girando derecha";
  else decision = "Detenido";
  
  String json = "{";
  json += "\"distances\":[" + String(currentDistances[0]) + "," + String(currentDistances[1]) + "," + String(currentDistances[2]) + "],";
  json += "\"decision\":\"" + decision + "\",";
  json += "\"servoAngle\":" + String(currentServoAngle);
  json += "}";
  
  server.send(200, "application/json", json);
}

9.-Programming: Interface (web page)

To begin programming the Xiaoesp32-c3 module, we'll start with the interface, as it will allow us to view all the robot's functionality. We'll use the Google Sites tool:

We will upload the HTML Code, once the Code is inserted we click on the following:

we will have a preview of the interface

10.-System Integration

The integration of the ZentinelBot consisted of uniting the different stages of the project: mechanical design, manufacturing, electronic system, and embedded programming, with the goal of obtaining a functional robot capable of patrolling and detecting activity in real time.

You can view more details in week 15.

The assembly begins with the joining of the main base, to which the side walls and structural supports are fixed using screws and nuts.

The robot assembly was carried out in several stages, beginning with the preparation of the mechanical parts, followed by the integration of the electronic components, and ending with functional testing.

11.-Final Tests

As a result of the tests carried out after assembly, it was verified that the robot correctly executes basic movements through manipulation of the control interface.

Integration Testing Results

As a result of the integration tests performed after the assembly, the robot was able to execute basic movements correctly through the control interface.

Observed Behavior:

• Forward and backward movement with immediate response to the sent commands.
• Left and right turns with accurate directional control.
• Complete stop upon receiving the stop command.
• Proper speed with no loss of traction in the wheels.

Control Interface:

The developed interface (web-based or via Bluetooth BLE) allows wireless command transmission to the ESP32-C3, which interprets the instructions and drives the motors using the L298N module.

Validated Integration:

All systems (electronic, mechanical, and control) work together in sync. The data flow between the interface and the microcontroller is stable, ensuring effective control of the robot's movements.

The ZentinelBot integrates a dual-lens IP camera that improves its vision by capturing images from two angles simultaneously. Thanks to this technology, the robot can transmit real-time video over Wi-Fi.

An integrated web interface allows remote control of the robot's motors and real-time viewing of the distance measured by the ultrasonic sensor.

As a final result, the ZentinelBot effectively integrates mobility, sensing, and remote control systems. Thanks to its dual-lens IP camera, it enables real-time visual monitoring from multiple angles. Its custom web interface offers intuitive motor control and instant visualization of data obtained by the ultrasonic sensor, allowing it to detect obstacles and navigate with greater precision.

Conclusions

The development of the ZentinelBot has been a highly rewarding and comprehensive experience, combining mechanical design, digital manufacturing, electronics, and programming. From the design and 3D printing of the chassis, a robust and modular structure was built that allowed for the proper installation of motors, sensors, and control boards. Once all the parts were assembled, the electronic system was integrated, followed by the loading of the programming code and the execution of functional tests.

Beyond building a robot, I learned to think systemically, iterate quickly, and find solutions within an ecosystem of open and collaborative tools. Every step, from designing the chassis to running final tests, allowed me to better understand the limits and possibilities of local and custom manufacturing.

This project represents not only a technical achievement but also a reflection of the Fab Academy spirit: learning by doing, sharing knowledge, and creating accessible solutions with real impact.

Link to files used this week

1. robot.ino
2. left leg.ipt
3. right leg.ipt
4. chest.ipt
5. antenna base.ipt
6. antenna cover.ipt
7. cover.ipt
8. mask.ino
9. mechanism.ipt